package com.browsesoft;

import java.awt.Container;
import java.awt.Window;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.Date;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;

import javax.servlet.ServletContext;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import javax.swing.JComponent;

import org.w3c.dom.Attr;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import com.aote.util.ThreadLocals;
import com.browsesoft.htmlcomponent.HTMLPage;
import com.browsesoft.listener.ContextListener;
import com.browsesoft.user.User;

public class Tools {
	/**
	 * 把以','分割的字符串分解成字符串向量
	 */
	public static LinkedList stringToLinkedList(String source) {
		return stringToLinkedList(source, ',');
	}

	/**
	 * 把实体列表转换成实体的id号列表
	 */
	public static LinkedList getIds(Collection entities) {
		LinkedList result = new LinkedList();
		for (Iterator iter = entities.iterator(); iter.hasNext();) {
			Entity e = (Entity) iter.next();
			result.add(e.getID());
		}
		return result;
	}

	/**
	 * 从实体列表中得到id号，把所有id号组织成一个串，id号之间用","分割。
	 * 
	 * @param iter
	 * @return
	 */
	public static String entitiesToIDString(Iterator iter) {
		String result = "";
		while (iter.hasNext()) {
			Entity entity = (Entity) iter.next();
			result += entity.getID() + ",";
		}
		if (result.endsWith(",")) {
			result = result.substring(0, result.length() - 1);
		}
		return result;
	}

	/**
	 * 把以给定字符分割的字符串分解成字符串向量
	 */
	public static LinkedList stringToLinkedList(String source, char ch) {
		LinkedList v = new LinkedList();
		if (source == null || source.equals("")) {
			return v;
		}
		int start = 0;
		int end = source.indexOf(ch);
		while (end != -1) {
			String str = source.substring(start, end);
			v.add(str);
			start = end + 1;
			end = source.indexOf(ch, start);
		}
		String str = source.substring(start);
		v.add(str);
		return v;
	}

	public static String getEntityType(String entityType) throws Exception {
		return PropertiesService.getPropertyForInvestment(entityType, "cname");
	}

	/**
	 * 专用于招商局项目 屏蔽空指针错误错误
	 */
	public static String getEntityTypeScreenNull(String entityType)
			throws Exception {
		String type = "";
		type = PropertiesService.getProperty(entityType, "cname");
		return type;
	}

	/**
	 * 将source中的值添加到target中，去掉重复内容
	 */
	public static void add(LinkedList target, LinkedList source) {
		int size = source.size();
		for (int i = 0; i < size; i++) {
			if (!target.contains(source.get(i))) {
				target.add(source.get(i));
			}
		}
	}

	/**
	 * 从Cookie数组中得到给定名字的Cookie值
	 */
	public static String getCookieValue(Cookie[] cookies, String name) {
		for (int i = 0; i < cookies.length; i++) {
			if (cookies[i].getName().toLowerCase().equals(name.toLowerCase())) {
				return cookies[i].getValue();
			}
		}
		return null;
	}

	/**
	 * 根据页面的调用时间来移走session中的页面
	 */
	public synchronized static void removeHTMLPage(HttpSession session)
			throws Exception {
		// 找到session中的所以页面列表
		LinkedList v = new LinkedList();
		synchronized (session) {
			Enumeration e = session.getAttributeNames();
			while (e.hasMoreElements()) {
				v.add(e.nextElement());
			}
		}
		for (int i = 0; i < v.size(); i++) {
			String n = (String) v.get(i);
			Object o = session.getAttribute(n);
			if (o instanceof HTMLPage && ((HTMLPage) o).isInvalid()) {
				session.removeAttribute(n);
			}
		}
	}

	public static StringBuffer ElementToString(Element e) {
		StringBuffer str = new StringBuffer(new String(
				"<?xml version=\"1.0\" encoding=\"GB2312\" ?>"));
		str.append(new String("<" + e.getNodeName() + " "
				+ getAttributesString(e) + ">"));
		NodeList list = e.getChildNodes();
		for (int i = 0; i < list.getLength(); i++) {
			Node node = list.item(i);
			if (node.getNodeType() == Node.ELEMENT_NODE) {
				ElementToString((Element) node, str);
			}
		}
		str.append("</" + e.getNodeName() + ">");
		return str;
	}

	private static void ElementToString(Element e, StringBuffer str) {
		str.append("<" + e.getNodeName() + " " + getAttributesString(e) + ">");
		NodeList list = e.getChildNodes();
		for (int i = 0; i < list.getLength(); i++) {
			Node node = list.item(i);
			if (node.getNodeType() == Node.ELEMENT_NODE) {
				ElementToString((Element) node, str);
			}
		}
		str.append("</" + e.getNodeName() + ">");
	}

	/**
	 * 得到节点属性字串
	 * 
	 * @param e
	 *            节点
	 * @return 属性字串
	 */
	private static String getAttributesString(Element e) {
		String str = "";
		NamedNodeMap nodeMap = e.getAttributes();
		if (nodeMap.getLength() >= 1) {
			for (int i = 0; i < nodeMap.getLength(); i++) {
				Node node = nodeMap.item(i);
				if (node.getNodeType() == Node.ATTRIBUTE_NODE) {
					String name = ((Attr) node).getName();
					String value = ((Attr) node).getValue();
					str += "" + name + "=\"" + value + "\" ";
				}
			}
			// str += "" + nodeMap.toString() + "";
		}
		return str;
	}

	public static String getAbsolutePath() {
		ServletContext context = ContextListener.getContext();
		String p = context.getRealPath("/");
		int endIndex = p.lastIndexOf('/');
		// 如果以"/"结尾，去掉
		if (endIndex != -1) {
			p = p.substring(0, endIndex);
		}
		return p;
	}

	/**
	 * 得到组件的类型为JFrame父组件
	 * 
	 * @param c
	 *            组件
	 * @return JFrame类型的父组件
	 */
	public static Window getParentWindow(JComponent c) {
		Container cont = c.getParent();
		while (!(cont instanceof Window)) {
			cont = cont.getParent();
		}
		return (Window) cont;
	}

	public static String LinkedListTostring(LinkedList v) {
		String result = LinkedListTostring(v, ",");
		return result;
	}

	public static String LinkedListTostring(LinkedList v, String limit) {
		String end = "";
		for (int i = 0; i < v.size(); i++) {
			end = end + v.get(i) + limit;
		}
		if (!end.equals("")) {
			end = end.substring(0, end.length() - 1);
		}
		return end;
	}

	/**
	 * 迭代转换成链表
	 */
	public static LinkedList iteratorToList(Iterator iter) {
		// 对迭代中的每一个对象，放到结果链表中
		LinkedList result = new LinkedList();
		while (iter.hasNext()) {
			result.add(iter.next());
		}
		return result;
	}

	/**
	 * 把迭代中的内容转换成以','分开的字符串
	 * 
	 * @param iter
	 *            迭代
	 * @return 以','分开的字符串
	 */
	public static String iteratorToString(Iterator iter) {
		String end = "";
		// 对于迭代中的每一项
		while (iter.hasNext()) {
			Object item = iter.next();
			end = end + item + ",";
		}
		if (!end.equals("")) {
			end = end.substring(0, end.length() - 1);
		}
		return end;
	}

	/**
	 * 根据所给的字符分割字串，返回前半部分
	 * 
	 * @param string
	 *            所要分割的字串
	 * @return 前半部分
	 */
	public static String getFirstStringByCh(String string, String character) {
		int index = string.indexOf(character);
		return string.substring(0, index);
	}

	/**
	 * 根据所给的字符分割字串，返回后半部分
	 * 
	 * @param string
	 *            所要分割的字串
	 * @return 后半部分
	 */
	public static String getlastStringByCh(String string, String character) {
		int index = string.indexOf(character);
		return string.substring(index + 1);
	}

	/**
	 * 根据所给的小写金额，把金额转换为大写
	 * 
	 * @param lower
	 *            需要转换的小写金额
	 * @return 转换后的大写金额
	 */
	public static String conventLowerToUpper(String lower) {
		// 定义转换后的大写字符和单位
		String upper = "零壹贰叁肆伍陆柒捌玖";
		String bit = "分角整元拾佰仟万拾佰仟亿拾佰仟";
		// 定义一个临时变量
		String temp = "";
		// 转换后返回的大写金额
		String upperMoney = "";
		// 金额的整数位长度
		int length = 0;
		// 去掉空格
		temp = lower.trim();
		// 如果得到的小写金额没有字符"."
		if (temp.indexOf(".") == -1) {
			length = temp.length();
		}
		// 否则如果有，整数位的长度为
		else {
			length = temp.indexOf(".");
		}
		// 位置变量
		int position = 0;
		// 数字对应的大写汉字
		String upperNum = "";
		// 数字对应的单位
		String unit = "";
		// 对于数字金额来说
		for (int i = 0; i < temp.length(); i++) {
			if (i > length + 2) {
				break;
			}
			if (i == length) {
				continue;
			}
			// 找出所得的数字对应的中文
			position = Integer.parseInt(String.valueOf(temp.charAt(i)));
			upperNum = upper.substring(position, position + 1);
			// 根据位数算得他的单位
			position = length - i + 2;
			unit = bit.substring(position, position + 1);
			// 得到的大写金额为
			upperMoney = upperMoney.concat(upperNum).concat(unit);
		}
		// 如果upperMoney中含有“零仟、零佰、零拾、零元、零角”的，都以零代替
		if (upperMoney.indexOf("零拾") != -1 || upperMoney.indexOf("零佰") != -1
				|| upperMoney.indexOf("零仟") != -1
				|| upperMoney.indexOf("零元") != -1
				|| upperMoney.indexOf("零角") != -1) {
			upperMoney = upperMoney.replaceAll("零拾", "零");
			upperMoney = upperMoney.replaceAll("零佰", "零");
			upperMoney = upperMoney.replaceAll("零仟", "零");
		}
		// 如果upperMoney中有相连的两个“零”，或三个、四个，都换为一个
		if (upperMoney.indexOf("零零") != -1 || upperMoney.indexOf("零零零") != -1
				|| upperMoney.indexOf("零零零零") != -1) {
			upperMoney = upperMoney.replaceAll("零零零零", "零");
			upperMoney = upperMoney.replaceAll("零零零", "零");
			upperMoney = upperMoney.replaceAll("零零", "零");
		}
		// 如果有零亿、零万或者零元,以亿、万或元代替
		if (upperMoney.indexOf("零亿") != -1 || upperMoney.indexOf("零万") != -1
				|| upperMoney.indexOf("零元") != -1) {
			upperMoney = upperMoney.replaceAll("零亿", "亿");
			upperMoney = upperMoney.replaceAll("零万", "万");
			upperMoney = upperMoney.replaceAll("零元", "元");
		}
		// 如果“万”前面是“亿”的话，把万去掉
		if (upperMoney.lastIndexOf("亿万") != -1) {
			upperMoney = upperMoney.replaceAll("亿万", "亿");
		}
		// 如果小写金额最后两位为零，补整
		if (upperMoney.lastIndexOf("零角零分") != -1) {
			upperMoney = upperMoney.replaceAll("零角零分", "整");
		}
		// 否则，如果有“零角”，以零代替
		else if (upperMoney.lastIndexOf("零角") != -1) {
			upperMoney = upperMoney.replaceAll("零角", "零");
		}
		// 如果有“零分”，以零代替
		if (upperMoney.lastIndexOf("零分") != -1) {
			upperMoney = upperMoney.replaceAll("零分", "");
		}
		// 如果整数位长度等于小写金额的位数，给大写金额加整
		if ((length == temp.length()) || (length == temp.length() - 1)) {
			upperMoney = upperMoney.concat("整");
		}
		// 如果最后一位为角，加整
		if (upperMoney.lastIndexOf("角") != -1) {
			upperMoney = upperMoney.concat("整");
		}
		if(upperMoney.endsWith("零"))
		{
			upperMoney = upperMoney.substring(0,upperMoney.length() - 1);
			upperMoney = upperMoney.concat("整");
		}
		// 如果小数位后只有一位数字，且为零，去零加整
		//if (upperMoney.lastIndexOf("零") != -1) {
		//	upperMoney = upperMoney.replaceAll("零", "整");
		//}
		return upperMoney;
	}

	/**
	 * 获得当前的日期 格式为yyyy－MM－dd
	 */
	private static java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat(
			"yyyyMMdd");

	public static String getDateOfToday() {
		String date = sdf.format(new Date());
		return date;
	}

	/**
	 * 转换系统日期格式
	 */
	public static String dateCovent(String date) {
		String year = date.substring(0, 4);
		String month = date.substring(4, 6);
		String day = date.substring(6, 8);
		return year + month + day;
	}

	/**
	 * 上一年最后一月
	 */
	public static String getLastdayOfYear() {
		String date = getDateOfToday();
		String year = date.substring(0, 4);
		String lastYear = Integer.toString(Integer.parseInt(year) - 1);
		return lastYear + "12";
	}

	/**
	 * 当年的年底
	 */
	public static String getCurrentYearLast() {
		String date = getDateOfToday();
		String year = date.substring(0, 4);
		return year + "12";
	}

	/**
	 * 本月月份
	 */
	public static String getCurrentMonth() {
		String date = getDateOfToday();
		String currentMonth = date.substring(0, 6);
		return currentMonth;
	}

	/**
	 * 获得当前的日期 格式为yyyy－MM－dd
	 */
	public static String getTimeOfToday() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String date = sdf.format(new Date());
		return date;
	}

	/**
	 * 根据组合的主题和标题字数重新设置标题
	 * 
	 * @param topic
	 *            组合的主题
	 * @param titleSize
	 *            模板上的标题字数
	 * @return 设置后的标题
	 */
	public static String getNewTopic(String topic, int titleSize) {
		int start = topic.indexOf("【");
		// 如果没有右边部分
		if (start == -1) {
			// 左边删除
			return topic.substring(0, topic.length() - 3) + "...";
		} else {
			// 右边不动，左边删除
			String left = topic.substring(0, start);
			// 如果无标题，不处理，返回标题
			if (left == null || left.equals("")) {
				return topic;
			}
			// 根据left本身的长度确定其最终显示长度,长度为原字符串长度的一半
			left = getViewStr(left, 2);
			String right = topic.substring(start);
			// // 右边也处理
			// if (topic.indexOf("<") != -1 && topic.indexOf(">") != -1) {
			// int star = right.indexOf("<");
			// String emailLeft = right.substring(0, star);
			// emailLeft = getViewStr(emailLeft, 2);
			// String emailRight = right.substring(star);
			// return left + "..." + emailLeft + "..." + emailRight;
			// } else {
			return left + "..." + right;
			// }
		}
	}

	/**
	 * 根据字符串本身的长度，确定其最终显示的长度
	 */
	private static String getViewStr(String str, int n) {
		int len = str.length();
		int viewLen = len / n;
		if (viewLen == 0) {
			viewLen = 1;
		}
		String result = str.substring(0, viewLen);
		return result;
	}

	/**
	 * 当该文件不存在时,创建文件
	 * 
	 * @return File 创建的文件对象的引用
	 */
	public static File createFileWhenNotExists(String filePath)
			throws Exception {
		File file = null;
		if (filePath != "" && !filePath.equals("")) {
			file = new File(filePath);
		} else {
			file = new File("./default/images");
		}
		// 如果路径中的文件夹,创建
		if (!file.exists()) {
			file.mkdirs();
		}
		return file;
	}

	/**
	 * 得到当前用户
	 */
	public static User getLoginUser() {
		User user = (User) ThreadLocals.loginUser.get();
		return user;
	}

	/**
	 * 得到某以属性值
	 */
	public static String getAttrValue(Hashtable ht, String key) {
		if (ht.get(key) == null) {
			return "";
		} else {
			return (String) ht.get(key);
		}
	}

	/**
	 * 用属性集合中属性替换表达式中#属性名#的内容
	 */
	public static String replaceAttrs(String exp, Map attrs) {
		String result = exp;
		// 对于旧属性中的每一项
		Iterator iter = attrs.entrySet().iterator();
		while (iter.hasNext()) {
			// 替换表达式中该属性内容
			Map.Entry item = (Map.Entry) iter.next();
			result = result.replaceAll("#" + item.getKey() + "#", (String) item
					.getValue());
		}
		return result;
	}

	/**
	 * 根据文档id号得到文档的实际名称
	 */
	public static String getRealName(String docId) {
		throw new UnsupportedOperationException();
	}

	/**
	 * 处理文档保存过程
	 */
	public static void saveDoc(HttpServletRequest request) {
		throw new UnsupportedOperationException();
	}
}